package com.probox.common.entity.service.platfom.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.probox.common.core.constant.CachePrefix;
import com.probox.common.core.constant.Constants;
import com.probox.common.core.enums.*;
import com.probox.common.core.exception.BaseException;
import com.probox.common.core.exception.PlatformException;
import com.probox.common.core.utils.SecurityUtils;
import com.probox.common.core.utils.StringUtils;
import com.probox.common.entity.domain.platfom.PlatformPageConfig;
import com.probox.common.entity.domain.platfom.vo.ConfigVo;
import com.probox.common.entity.domain.platfom.vo.UseTypeVo;
import com.probox.common.entity.domain.platfom.vo.api.PlatformComponentDataVo;
import com.probox.common.entity.domain.platfom.vo.api.PlatformComponentVo;
import com.probox.common.entity.domain.platfom.vo.api.PlatformPageVo;
import com.probox.common.entity.domain.platfom.vo.api.PlatformTemplateView;
import com.probox.common.entity.mapper.platfom.PlatformPageConfigMapper;
import com.probox.common.entity.service.platfom.IPlatformPageConfigComponentService;
import com.probox.common.entity.service.platfom.IPlatformPageConfigDataService;
import com.probox.common.entity.service.platfom.IPlatformPageConfigService;
import com.probox.common.redis.service.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 模板或店铺页面配置Service业务层处理
 *
 * @date 2021-06-10
 */
@Service
@Transactional
public class PlatformPageConfigServiceImpl extends ServiceImpl<PlatformPageConfigMapper, PlatformPageConfig> implements IPlatformPageConfigService {
    @Autowired
    private PlatformPageConfigMapper platformPageConfigMapper;

    @Autowired
    private IPlatformPageConfigComponentService platformPageConfigComponentService;

    @Autowired
    private IPlatformPageConfigDataService platformPageConfigDataService;

    @Autowired
    private RedisService redisService;

    private static final Logger logger = LoggerFactory.getLogger(PlatformPageConfigServiceImpl.class);


    /**
     * 查询模板或店铺页面配置
     *
     * @param pageUid 模板或店铺页面配置ID
     * @return 模板或店铺页面配置
     */
    @Override
    public PlatformPageConfig selectPlatformPageConfigById(Long pageUid) {
        return this.getById(pageUid);
    }


    @Override
    public PlatformPageConfig getTemplatePage(Long uid) {
        QueryWrapper<PlatformPageConfig> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("PLATFORM_UID", uid);
        queryWrapper.eq("DATA_STATUS", DataStatus.valid.getKey());
        return platformPageConfigMapper.selectOne(queryWrapper);
    }

    /**
     * 查询模板或店铺页面配置列表
     *
     * @param platformPageConfig 模板或店铺页面配置
     * @return 模板或店铺页面配置
     */
    @Override
    public List<PlatformPageConfig> queryList(PlatformPageConfig platformPageConfig) {
        QueryWrapper<PlatformPageConfig> queryWrapper = Wrappers.query();
        if (StringUtils.isNotEmpty(String.valueOf(platformPageConfig.getPageUid())) && platformPageConfig.getPageUid() != null) {
            queryWrapper.eq("PAGE_UID", platformPageConfig.getPageUid());
        }
        if (StringUtils.isNotEmpty(String.valueOf(platformPageConfig.getTemplateId())) && platformPageConfig.getTemplateId() != null) {
            queryWrapper.eq("TEMPLATE_ID", platformPageConfig.getTemplateId());
        }
        if (StringUtils.isNotEmpty(String.valueOf(platformPageConfig.getPlatformUid())) && platformPageConfig.getPlatformUid() != null) {
            queryWrapper.eq("PLATFORM_UID", platformPageConfig.getPlatformUid());
        }
        if (StringUtils.isNotEmpty(String.valueOf(platformPageConfig.getDataStatus())) && platformPageConfig.getDataStatus() != null) {
            queryWrapper.eq("DATA_STATUS", platformPageConfig.getDataStatus());
        }
        return platformPageConfigMapper.selectList(queryWrapper);
    }

    /**
     * 新增模板或店铺页面配置
     *
     * @param platformTemplateView 模板信息
     * @return 结果
     */
    @Override
    public void insertPlatformPageConfig(PlatformTemplateView platformTemplateView) {
        List<PlatformPageVo> page = platformTemplateView.getPage();
        //if (ObjectUtil.isEmpty(page)) throw new PlatformException("模板信息有问题,请重新添加");
        if (ObjectUtil.isNotEmpty(page)) {
            page.forEach(vo -> {

                PlatformPageConfig pageConfig = savePage(platformTemplateView, vo, null);
                vo.setPageUid(pageConfig.getPageUid());
                platformPageConfigComponentService.insertPlatformPageConfigComponent(platformTemplateView, vo);
            });
        }
    }

    /**
     * 复制模板页面数据
     *
     * @param view
     * @param templateId 要复制给谁的id
     */
    @Override
    public void copyPlatformPageConfig(PlatformTemplateView view, Long templateId) {
        PlatformPageConfig config = new PlatformPageConfig();
        config.setDataStatus(view.getPublishStatus());
        config.setTemplateId(view.getTemplateId());
        List<PlatformPageConfig> platformPageConfigs = queryList(config);
        if (ObjectUtil.isEmpty(platformPageConfigs)) throw new PlatformException("模板信息有误,请刷新页面！");
        platformPageConfigs.forEach(page -> {
            Long uid = page.getPageUid();
            page.setTemplateId(templateId);
            page.setDataStatus(PublishStatusEnum.draft.getKey());
            PlatformPageConfig pageConfig = savePage(view, null, page);
            platformPageConfigComponentService.copyPlatformPageConfigComponent(view, uid, pageConfig.getPageUid());
        });
    }

    /**
     * 获取信息vo
     *
     * @param platformPageConfig
     * @return
     */
    @Override
    public List<PlatformPageVo> getPlatformPageVoList(PlatformPageConfig platformPageConfig, Long platformUid, UseTypeVo useTypeVo) {
        List<PlatformPageVo> vos = platformPageConfigMapper.getVo(platformPageConfig);
        List<PlatformPageVo> list = new ArrayList<>();
        if (ObjectUtil.isNotEmpty(vos)) {
            vos.forEach(vo -> {
                PlatformPageVo pageVo = new PlatformPageVo();
                BeanUtils.copyProperties(vo, pageVo);
                pageVo.setComponent(platformPageConfigComponentService.getComponentVoList(pageVo.getPageUid(), platformUid, useTypeVo));
                list.add(pageVo);
            });
        }

        return list;
    }

    /**
     * 获取各种页面的在线配置
     *
     * @param configVo
     * @return
     */
    @Override
    public List<PlatformPageVo> getOnlinePageVoList(ConfigVo configVo) {
        long time = DateUtil.date().getTime();
        // 获得当前平台正在发布状态的模板
        configVo.setPlatformUid(SecurityUtils.getCustomerPlatformUid());
        String jue = "1";
        // 根据类型进行获取
        String key = "";
        if (PageTypeEnum.proPage.getKey().equals(configVo.getPageType())) {
            key = CachePrefix.TEMPLATE_MALL_PAGE + configVo.getPlatformUid();
            jue = "0";
            // 强制刷新
            if (ObjectUtil.isNotEmpty(configVo.getSign()) && "refresh".equals(configVo.getSign())) {
                String k = CachePrefix.TEMPLATE_SIGN + configVo.getPlatformUid();
                Long incr = redisService.incr(k, 30L, TimeUnit.SECONDS);
                logger.debug("---------------------------第" + incr + "次进来-------------------------------------------------------");
                if (incr <= 1) {
                    redisService.deleteObject(key);
                    logger.debug("---------------------------刷新一次-------------------------------------------------------");
                }
            }
        }
        if (PageTypeEnum.classPage.getKey().equals(configVo.getPageType())) {
            key = CachePrefix.TEMPLATE_CLASS_PAGE + configVo.getPlatformUid();
        }
        if (PageTypeEnum.myPage.getKey().equals(configVo.getPageType())) {
            key = CachePrefix.TEMPLATE_MY_PAGE + configVo.getPlatformUid();
        }

        if (PageTypeEnum.homePage.getKey().equals(configVo.getPageType())) {
            key = CachePrefix.TEMPLATE_HOME_PAGE + configVo.getPlatformUid();
        }
        if ("".equals(key)) throw new BaseException("参数有问题！");
        List<PlatformPageVo> list = redisService.getCacheList(key);
        if (ObjectUtil.isEmpty(list)) {
            list = new ArrayList<>();
            List<PlatformPageVo> onlineVo = platformPageConfigMapper.getOnlineVo(configVo);
            if (ObjectUtil.isEmpty(onlineVo)) return list;
            for (PlatformPageVo vo : onlineVo) {
                PlatformPageVo pageVo = new PlatformPageVo();
                BeanUtils.copyProperties(vo, pageVo);
                pageVo.setComponent(platformPageConfigComponentService.getComponentVoList(pageVo.getPageUid(), configVo.getPlatformUid()));
                PlatformPageVo tmp = platformPageConfigDataService.getDataVoForVO(pageVo, configVo.getPlatformUid());
                List<PlatformComponentVo> componentVos = tmp.getComponent();
                for(PlatformComponentVo c:componentVos){
                    List<PlatformComponentDataVo> dataVos = c.getData();
                    for(PlatformComponentDataVo d:dataVos){
                        if (StringUtils.isNotEmpty(d.getDataImage())){
                            if (!d.getDataImage().endsWith(Constants.WEBP)){
                                d.setDataImage(d.getDataImage()+Constants.WEBP);
                            }
                        }
                    }
                }
                list.add(tmp);
            }
            redisService.setCacheList(key, list);
            /*
            if ("0".equals(jue)) redisService.expire(key, 5L, TimeUnit.MINUTES);
            else redisService.expire(key, RedisService.ThirtySecond, TimeUnit.SECONDS);
             */
        }
        /*
        if (PageTypeEnum.proPage.getKey().equals(configVo.getPageType())) list = reckonTime(list, configVo, time);
        if (ObjectUtil.isNotEmpty(SecurityUtils.getCustomerUid()))
            if (PageTypeEnum.homePage.getKey().equals(configVo.getPageType())) list = formatList(list);

         */
        return list;
    }


    private List<PlatformPageVo> formatList(List<PlatformPageVo> list) {
        List<PlatformPageVo> addList = new ArrayList<>();
        list.forEach(vo -> {
            List<PlatformComponentVo> component = vo.getComponent();
            List<PlatformComponentVo> addComponent = new ArrayList<>();
            component.forEach(listVo -> { //判断是否需要计算时间
                if (!ObjectUtil.isEmpty(ComponentTypeEnum.getNameByKey(listVo.getComponentType()))) {
                    List<PlatformComponentDataVo> data = listVo.getData();
                    List<PlatformComponentDataVo> addData = new ArrayList<>();
                    data.forEach(dataVo -> {
                        if (ComponentDataType.img.getKey().equals(dataVo.getDataType())) {
                            if (ObjectUtil.isNotEmpty(dataVo.getDataLink())) {
                                String dataLink = dataVo.getDataLink();
                                String[] split = dataLink.split("&desc");
                                if (split.length >= 2 && !"".equals(split[1])) {
                                    String format = String.format(split[0], "ZKTC-" + SecurityUtils.getCustomerUid());
                                    dataVo.setDataLink(format + "&desc" + split[1]);
                                }
                            }
                        }
                        addData.add(dataVo);
                    });
                    listVo.setData(addData);
                }
                addComponent.add(listVo);
            });
            vo.setComponent(addComponent);
            addList.add(vo);
        });
        return addList;
    }

    /**
     * 重新计算时间
     *
     * @param list
     * @param configVo
     * @param time
     * @return
     */
    private List<PlatformPageVo> reckonTime(List<PlatformPageVo> list, ConfigVo configVo, long time) {
        List<PlatformPageVo> addList = new ArrayList<>();
        list.forEach(vo -> {
            List<PlatformComponentVo> component = vo.getComponent();
            List<PlatformComponentVo> addComponent = new ArrayList<>();
            component.forEach(listVo -> { //判断是否需要计算时间
                if (!ObjectUtil.isEmpty(ComponentTypeEnum.getNameByKey(listVo.getComponentType()))) {
                    List<PlatformComponentDataVo> data = listVo.getData();
                    List<PlatformComponentDataVo> addData = new ArrayList<>();
                    data.forEach(dataVo -> {
                        if (ComponentDataType.activity.getKey().equals(dataVo.getDataType())) {
                            HashMap map = dataVo.getDataVo();
                            if (ObjectUtil.isNotEmpty(map)) {
                                if (ObjectUtil.isNotEmpty(map.get("beginTime"))) {
                                    Object beginTimeM = map.get("beginTime");
                                    Date beginTime = DateUtil.parse(beginTimeM.toString());
                                    if (beginTime != null && beginTime.getTime() > time) {
                                        map.put("statrTimes", beginTime.getTime() - time);
                                    } else {
                                        map.put("statrTimes", 0L);
                                    }
                                }
                                if (ObjectUtil.isNotEmpty(map.get("endTime"))) {
                                    Object endTimeM = map.get("endTime");
                                    Date endTime = DateUtil.parse(endTimeM.toString());
                                    if (endTime != null && endTime.getTime() > System.currentTimeMillis()) {
                                        map.put("endTimes", endTime.getTime() - time);
                                    } else {
                                        map.put("endTimes", 0L);
                                    }

                                }
                            }
                            dataVo.setDataVo(map);
                        }
                        addData.add(dataVo);
                    });
                    listVo.setData(addData);
                }
                addComponent.add(listVo);
            });
            vo.setComponent(addComponent);
            addList.add(vo);
        });
        return addList;
    }

    /**
     * 校验是否有发布的版本
     *
     * @param configVo
     * @return
     */
    @Override
    public boolean checkOnLive(ConfigVo configVo) {
        List<PlatformPageVo> onlineVo = platformPageConfigMapper.getOnlineVo(configVo);
        if (ObjectUtil.isEmpty(onlineVo)) return false;
        else {
            if (ObjectUtil.isNotEmpty(onlineVo.get(0))) return true;
            else return false;
        }
    }


    /**
     * 修改页面配置信息
     *
     * @param view
     */
    @Override
    public void updatePlatformPageConfig(PlatformTemplateView view) {
        List<PlatformPageVo> page = view.getPage();
        removeComponent(view.getTemplateId(), PublishStatusEnum.revisions.getKey(), null, null, null);
        //if (ObjectUtil.isEmpty(page)) throw new PlatformException("模板信息有问题,请重新添加");
        if (ObjectUtil.isNotEmpty(page)) {
            page.forEach(vo -> {
                if (ObjectUtil.isEmpty(vo.getPageUid())) {
                    PlatformPageConfig pageConfig = savePage(view, vo, null);
                    vo.setPageUid(pageConfig.getPageUid());
                    platformPageConfigComponentService.insertPlatformPageConfigComponent(view, vo);
                } else {
                    editPage(view, vo);
                    platformPageConfigComponentService.updatePlatformPageConfigComponent(view, vo);
                }
            });
        }
    }

    @Override
    public void removeComponent(Long templateId, String dataStatus, Long platformUid, Long unTemplateUid, List<Long> aLong) {
        UpdateWrapper<PlatformPageConfig> updateWrapper = new UpdateWrapper<>();
        if (ObjectUtil.isEmpty(platformUid)) {
            updateWrapper.eq("TEMPLATE_ID", templateId);
        } else {
            updateWrapper.in("TEMPLATE_ID", aLong);
            updateWrapper.eq("PLATFORM_UID", platformUid);
            updateWrapper.ne("TEMPLATE_ID", unTemplateUid);
        }
        updateWrapper.set("DATA_STATUS", dataStatus);
        updateWrapper.set("UPDATE_UID", SecurityUtils.getUserId());
        updateWrapper.set("UPDATE_NAME", SecurityUtils.getUsername());
        updateWrapper.set("UPDATE_TIME", DateUtil.date());
        this.update(updateWrapper);
    }

    private PlatformPageConfig savePage(PlatformTemplateView view, PlatformPageVo vo, PlatformPageConfig config) {
        PlatformPageConfig pageConfig = new PlatformPageConfig();
        if (ObjectUtil.isEmpty(config)) {
            BeanUtils.copyProperties(vo, pageConfig);
            pageConfig.setPlatformUid(view.getPlatformUid());
            pageConfig.setTemplateId(view.getTemplateId());
        } else {
            BeanUtils.copyProperties(config, pageConfig);
            pageConfig.setPlatformUid(view.getPlatformUid());
            pageConfig.setPageUid(null);
        }
        pageConfig.setCreateName(view.getUserName());
        pageConfig.setCreateUid(view.getUserId());
        pageConfig.setCreateTime(view.getTime());
        boolean save = this.save(pageConfig);
        if (!save) throw new PlatformException("添加模板页面失败,请稍后再试！");
        return pageConfig;
    }

    private PlatformPageConfig editPage(PlatformTemplateView view, PlatformPageVo vo) {
        PlatformPageConfig pageConfig = new PlatformPageConfig();
        //if (ObjectUtil.isEmpty(vo)) throw new PlatformException("模板页面信息有误,请重试添加!");
        BeanUtils.copyProperties(vo, pageConfig);
        pageConfig.setPlatformUid(view.getPlatformUid());
        pageConfig.setTemplateId(view.getTemplateId());
        pageConfig.setUpdateName(view.getUserName());
        pageConfig.setUpdateUid(view.getUserId());
        pageConfig.setUpdateTime(view.getTime());
        this.updateById(pageConfig);
        return pageConfig;
    }

    /**
     * 获取上一次发布的模板
     *
     * @param templateUid
     * @return
     */
    @Override
    public Long getOnTine(Long templateUid) {
        QueryWrapper<PlatformPageConfig> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("platform_uid", SecurityUtils.getPlatformId());
        queryWrapper.ne("TEMPLATE_ID", templateUid);
        queryWrapper.eq("data_status", PublishStatusEnum.publish.getKey());
        List<PlatformPageConfig> platformPageConfigs = platformPageConfigMapper.selectList(queryWrapper);
        if (ObjectUtil.isEmpty(platformPageConfigs)) return 0L;
        if (ObjectUtil.isEmpty(platformPageConfigs.get(0))) return 0L;
        return platformPageConfigs.get(0).getTemplateId();
    }

}
